home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1994 / MacHack 1994.toast / MacHack™ 1987-1994 / MacHack™ '91 / '91 Attendee Contributions / Rotate Src / Rotate.a < prev    next >
Encoding:
Text File  |  1991-06-20  |  13.9 KB  |  489 lines  |  [TEXT/MPS ]
  1. ;    Bitmap rotation routines
  2.  
  3. ;    Copyright © 1989 Bob Spence
  4. ;    All rights reserved.
  5.  
  6.     INCLUDE 'QuickEqu.a'
  7.     INCLUDE 'Traps.a'
  8.  
  9. ;
  10. ; Rotation States
  11. ;
  12. ;    no rotation        rotate 180
  13. ;    (0)    1 2            (X)    4 3
  14. ;        3 4                2 1
  15. ;
  16. ;    mirror            mirror
  17. ;    horizontal        vertical
  18. ;    (H)    2 1            (V)    3 4
  19. ;        4 3                1 2
  20. ;
  21. ;    rotate left        rotate right
  22. ;    (L)    2 4            (R    3 1
  23. ;        1 3                4 2
  24. ;
  25. ;     flip left         flip right
  26. ;  (FL)    1 3           (FR)    4 2
  27. ;        2 4                3 1
  28. ;
  29.  
  30. ;
  31. ;    Rotation State Table
  32. ;
  33. ;              Rotate  Mirror  Mirror  Rotate  Rotate
  34. ;      State       180      Horiz       Vert       Left      Right        FL        FR
  35. ; 
  36. ;        0        X        H        V        L        R        FL        FR
  37. ;        H        V        0        X        FL        FR        L        R
  38. ;        V        H        X        0        FR        FL        R        L
  39. ;        X        0        V        H        R        L        FR        FL
  40. ;        L        R        FR        FL        X        0        H        V
  41. ;        R        L        FL        FR        0        X        V        H
  42. ;       FL        FR        R        L        V        H        0        X
  43. ;       FR        FL        L        R        H        V        X        0
  44. ;
  45.  
  46. ; typedef enum {Rot0, RotH, RotV, RotX,
  47. ;                RotL, RotR, RotFR, RotFL} RotationSw;
  48.  
  49. Rot0    EQU    0
  50. RotH    EQU    1
  51. RotV    EQU    2
  52. RotX    EQU    3
  53. RotL    EQU    4
  54. RotR    EQU    5
  55. RotFL    EQU    6
  56. RotFR    EQU    7
  57.  
  58. ; PROCEDURE CalcRotate(OldState, NewRotate: RotationSw): RotationSw;
  59. ; parameter offsets (in Pascal order)
  60. NEW_ROTATE    EQU 4+4
  61. OLD_STATE    EQU NEW_ROTATE+4
  62.  
  63.     EXPORT    CALC_ROTATE
  64. CALC_ROTATE    PROC
  65.     Link    A6,#0
  66.     Move.L    OLD_STATE(A6),D0     ; Get the rotation state
  67.     Lsl.W    #3,D0
  68.     Add.W    NEW_ROTATE(A6),D0 ; Apply the new rotation
  69.     And.W    #$3F,D0
  70.     Move.L    RotState,A0        ; Point to the transformation table
  71.     Move.B    (A0,D0.W),-2(A6) ; Return the resultant rotation state
  72.     Unlk    A6
  73.     Move.L    (sp)+,A0        ; Get return address and
  74.     Add.L    #8,sp            ; pop parameters off stack
  75.     Jmp        (A0)            ; for a Pascal style return
  76.  
  77. RotState    ; Indexed by state and rotation, giving new rotation state
  78.     DC.B     Rot0, RotX, RotH, RotV, RotL, RotR, RotFL,RotFR
  79.     DC.B    RotH, RotV, Rot0, RotX, RotFL,RotFR,RotL, RotR
  80.     DC.B    RotV, RotH, RotX, Rot0, RotFR,RotFL,RotR, RotL
  81.     DC.B    RotX, Rot0, RotV, RotH, RotR, RotL, RotFR,RotFL
  82.     DC.B    RotL, RotR, RotFR,RotFL,RotX, Rot0, RotH, RotV
  83.     DC.B    RotR, RotL, RotFL,RotFR,Rot0, RotX, RotV, RotH    
  84.     DC.B    RotFL,RotFR,RotR, RotL, RotV, RotH, Rot0, RotX
  85.     DC.B    RotFR,RotFL,RotL, RotR, RotH, RotV, RotX, Rot0
  86.  
  87.     ENDPROC
  88.     
  89. ;    The user may also select rotation of the image 90° left, right, or
  90. ;     180° as well as mirroring of the image horizontally and vertically.
  91.  
  92.  
  93.  
  94. ; Register usage
  95. ;    A0 = Input bitmap or current data pointer
  96. ;    A1 = Output bitmap or current data pointer
  97. ;    D0 & D1 = temp variables
  98. ;    D2..D7  = part of 16 word rotation matrix
  99.  
  100. ; Named register storage
  101.  
  102. InBase        EQU A2            ; Input BitMap row base address (when rotated)
  103. OutBase        EQU A2            ; Output BitMap row base address (when mirrored)
  104. InBytes        EQU A3            ; Input BitMap rowBytes
  105. xD0            EQU    A4            ; Temp storage for D0 in D0..D7 data block
  106. xD1            EQU    A5            ; Temp storage for D1 in D0..D7 data block
  107.  
  108. ; Local variable stack offsets
  109.  
  110. RowPtr        EQU    -4            ; Temp storage for output word pointer
  111. LowBound    EQU    RowPtr-4    ; Lowest output word address
  112. HiBound        EQU    LowBound-4    ; Highest output word address
  113. OutBytes    EQU    HiBound-2    ; Output BitMap rowBytes 
  114. InWords        EQU    OutBytes-2    ; Words in an input row (-1 for Dbra))
  115. InRows        EQU    InWords-2    ; Rows in the input BitMap
  116. OutRows        EQU    InRows-2    ; Rows in the output BitMap
  117. WordCnt        EQU    OutRows-2    ; Temp storage for Word loop counter
  118. LOCALSZ        EQU    WordCnt-2    ; Total space needed for local variables
  119.  
  120. ; The following Macros are used to:
  121. ;    Initialize the rotation loops
  122. ;    Load registers with input to transform
  123. ;    Transform the data
  124. ;    Loop thru the data as needed, and return
  125.  
  126. ;    
  127. ; Macros used to rotate a BitMap [left, right, flip left, flip right]
  128. ;
  129. ; Used by LOAD_REGS to fill a D register with the next 2 column words
  130.     MACRO
  131.     LOAD_REG    &Dreg
  132.     Move.W    (A0),&Dreg        ; Get a word
  133.     Add.L    InBytes,A0        ; Drop to next row
  134.     Swap    &Dreg            ; Put it into hi word
  135.     Move.W    (A0),&Dreg        ; Get a word
  136.     Add.L    InBytes,A0        ; Drop to next row
  137.     Swap    &Dreg            ; Restore 1st word low, 2nd word hi
  138.     ENDM
  139.  
  140. ; Establish the tops of the 16 word block rotate loops and
  141. ; load a 16 word block of data to rotate in the D registers
  142.     MACRO
  143.     LOAD_REGS &Loop
  144.     Move.L    A1,RowPtr(A6)    ; Save output's word address
  145. &Loop.Col:                    ; Top of the column loop
  146.     Move.W    InWords(A6),D0    ; Word count to process, this row
  147. &Loop.Row:                    ; Top of the row loop
  148.     Move.W    D0,WordCnt(A6)    ; Save loop counter, we need D0
  149.     Move.L    A0,InBase        ; Save the current input address
  150.     ; generate LOAD_REG D0..D7
  151.     LCLA    &n
  152. &n    SETA    0
  153.     WHILE    &n <= 7 DO
  154.     LOAD_REG D&n
  155. &n    SETA    &n + 1
  156.     ENDW
  157.     Move.L    D0,xD0            ; Save working D0 and D1 regs
  158.     Move.L    D1,xD1
  159.     Add.L    #2,InBase        ; Point to next input word block
  160.     Move.L    InBase,A0        ; Restore the start of input
  161.     Move.W    #15,D0            ; Do 16 Dbra loops
  162. &Loop.Word:                    ; Top of the 16 bit loop
  163.     Swap    D0                ; Save bit loop count, we need a word D0
  164.     ENDM
  165.  
  166. ; Rotate a bit from the left or right (&fr) of each word in Dx
  167. ; into the left or right (&to) of the D0 result word
  168.     MACRO
  169.     RotREG &fr,&to,&Dreg
  170.     Rox&fr..W    #1,&Dreg    ; Get an input bit
  171.     Rox&to..W    #1,D0        ; Set the output bit
  172.     Swap        &Dreg        ; Get the 2nd, hi word
  173.     Rox&fr..W    #1,&Dreg    ; Get the next input bit
  174.     Rox&to..W    #1,D0        ; Set the output bit
  175.     Swap        &Dreg        ; Restore hi and lo words
  176.     ENDM
  177.     
  178. ; Get 16 bits from the 16 Dx words, rotated into D0
  179.     MACRO
  180.     ROT_REGS &fr,&to
  181.     ; generate RotREG D0..D7
  182.     LCLA    &n
  183. &n    SETA    0
  184.     WHILE    &n <= 7 DO
  185.     IF        &n <= 1 THEN
  186.     Move.L    xD&n,D1            ; xD0 and xD1 share D1
  187.     RotREG    &fr,&to,D1
  188.     Move.L    D1,xD&n
  189.     ELSE
  190.     RotREG    &fr,&to,D&n
  191.     ENDIF
  192. &n    SETA    &n+1
  193.     ENDW
  194.     Move.W    D0,(A1)            ; Store the rotated output word
  195.     ENDM
  196.  
  197. ; Check the word, row and column loops, cleanup, and return
  198.     MACRO
  199.     END_ROTATE &Loop,&AdSb1,&AdSb2
  200.     &AdSb1..W OutBytes(A6),A1 ; Add/Subtract to next output row
  201.     Swap    D0                ; Get the bit loop count
  202.     IF &AdSb1 = 'Add' THEN
  203.     CMP.L    HiBound(A6),A1    ; If slop on the bottom been exceeded,
  204.     BGT.s    &Loop.End        ;  we will go to next column
  205.     ELSE
  206.     CMP.L    LowBound(A6),A1    ; If slop on the bottom been rotated up,
  207.     BLT.s    &Loop.End        ;  we will go to next column
  208.     ENDIF
  209.     Dbra    D0,&Loop.Word
  210. &Loop.End
  211.     Move.W    WordCnt(A6),D0    ; Get row width word loop count
  212.     Dbra    D0,&Loop.Row
  213.     &AdSb2..L #2,RowPtr(A6)    ; Add/Sub to next output word of row
  214.     Move.L    RowPtr(A6),A1    ; Restore to start of next output word
  215.     Move.L    InBytes,D0        ; Get the input rowBytes
  216.     Lsl.L    #4,D0            ; A0 has wrapped to 1st column, 2nd word
  217.     Sub.L    InBytes,D0        ; so offset = 15 * InBytes
  218.     Add.L    D0,A0            ; Point to next A0 in word 15 rows beyond
  219.     Sub.W    #16,InRows(A6)    ; Drop down to rotate next 16 rows
  220.     Bgt        &Loop.Col        ; When the rows are zero, we're done
  221.     ENDM
  222. ;
  223. ; Macros to mirror BitMaps [horizontal, vertical, 180°, null]
  224. ;
  225. ; Establish the tops of the mirroring loops
  226.     MACRO
  227.     GET_REG &Loop
  228. &Loop.Col:
  229.     Move.L    A1,OutBase        ; Save the start of output
  230.     Move.W    D1,D2            ; Set the Width loop count
  231. &Loop.Row:
  232.     ENDM
  233.  
  234. ; Transfer a word from input to output, unchanged
  235.     MACRO
  236.     GET_WORD    
  237.     Move.W    (A0)+,D0        ; Just get an input word, it's Ok as is
  238.     Move.W    D0,(A1)+        ; Store the word
  239.     ENDM
  240.  
  241. ; Transfer a word from input to output, bits reversed
  242.     MACRO
  243.     REVERSE_REG    
  244.     Move.W    (A0)+,D3        ; Reverse the 16 bits in word D3 
  245.     LCLA    &n
  246. &n    SETA    0
  247.     WHILE    &n <= 15 DO
  248.     Roxr.W    #1,D3            ; Take a bit from the right
  249.     Roxl.W    #1,D0            ;  and insert it to the left
  250. &n    SETA    &n + 1
  251.     ENDW
  252.     Move.W    D0,-(A1)        ; Store the word
  253.     ENDM
  254.  
  255. ; Check the word, row and column loops, cleanup, and return
  256.     MACRO
  257.     END_MIRROR &Loop,&ASub
  258.                             ; Loop,Add/Sub
  259.     Dbra    D2,&Loop.Row    ; Loop thru row's width
  260.     Move.L    OutBase,A1        ; Restore to start of row
  261.     &ASub..L InBytes,A1        ; Add/Sub to next row
  262.     Sub.W    #1,InRows(A6)    ; Drop to next row
  263.     Bgt.s    &Loop.Col        ; When the rows are zero, we're done
  264.     ENDM
  265.  
  266. ; Shift words left by the slop bits    
  267.     MACRO
  268.     SHIFT_WORDS
  269.     LCLA    &n
  270. &n    SETA    0
  271.     WHILE    &n <= 7 DO
  272.     Move.W    -(A0),D0    ; Get a word in the low word
  273.     Rol.L    D4,D0        ; Shift out the slop bits, round in good ones
  274.     Move.W    D0,(A0)        ; Store good word
  275.     Rol.L    D3,D0        ; Shift remaining good bits to top of long word
  276. &n    SETA    &n + 1
  277.     ENDW
  278.     ENDM    
  279.  
  280. ;
  281. ; The bit rotation routine
  282. ; PROCEDURE Rotate (sourceMap, destMap: bitMap);
  283. ;
  284. ; Initialize loops, jump to specific rotation macros, and return
  285. ;
  286. ; parameter offsets (in Pascal order)
  287. DEST_MAP    EQU 4+4
  288. SOURCE_MAP    EQU DEST_MAP+4
  289. ROTATION    EQU SOURCE_MAP+4
  290.  
  291. Btop         EQU  D1     ; Some BitMap bounds Rect defines
  292. Bleft        EQU  D2    
  293. Bbottom        EQU  D3
  294. Bright        EQU  D4
  295.  
  296.     EXPORT    ROTATE
  297. ROTATE    PROC
  298.     Link    A6,#LOCALSZ              ; Allocate temporary storage
  299.     Movem.L    D2-D7/A2-A5,-(sp)     ; D0-D1/A0-A1 are scratch in Pascal and C
  300.     Move.L    SOURCE_MAP(A6),A2     ; Get the source BitMap address
  301.     Move.L    DEST_MAP(A6),A1          ; Get the destination BitMap address
  302.     Moveq    #0,D0
  303.     Move.L    D0,D1
  304.     Move.W    rowBytes(A2),D1        ; Get the input rowBytes
  305.     Move.L    D1,InBytes            ; Set the row byte count
  306.     Lsr.W    #1,D1                ; Convert to words
  307.     Sub.W    #1,D1                ;  minus 1 (for Dbra)
  308. ;;    Move.W    D1,InWords(A6)
  309.     Movem.W    bounds(A2),D1-D4    ; Get the source bounds Rect
  310.     Move.W    Bright,D0
  311.     Sub.W    Bleft,D0
  312.     Asr.W    #4,D0                ; its words, really
  313.     Move.W    D0,InWords(A6)
  314.     Move.W    Bbottom,D0
  315.     Sub.W    Btop,D0
  316.     Move.W    D0,InRows(A6)        ; Set the input number of rows
  317.     Cmp.B    #RotL,ROTATION(A6)    ; Is the destination not rotated
  318.     Blt.s    NoRotate
  319.     Sub.W    Bright,D0            ; Rotate the bounds Rect
  320.     Add.W    Bleft,D0            ; (Bbottom - Btop) - (Bright - Bleft);
  321.     Sub.W    D0,Bbottom
  322.     Add.W    D0,Bright
  323. NoRotate
  324.     Movem.W    D1-D4,bounds(A1) ; Set the destination bounds Rect
  325.     Move.W    Bbottom,D5
  326.     Sub.W    Btop,D5
  327.     Move.W    D5,OutRows(A6)    ; Set the destination row count
  328.  
  329.     Move.W    Bright,D6        ; Compute rowBytes
  330.     Sub.W    Bleft,D6        ;  forced to word boundary
  331.     Add.W    #15,D6
  332.     Lsr.W    #4,D6            ; (Bright - Bleft + 15) / 16) * 2
  333.     Lsl.W    #1,D6
  334. ;;    Move.W    D6,rowBytes(A1)    ; Set the destination rowBytes
  335.     Move.W    rowBytes(A1),D6    ; Get the destination rowBytes
  336.     Move.W    D6,OutBytes(A6)
  337.     Mulu    D6,D5            ; Compute destination map size
  338.     Addq    #2,D5            ;  rowBytes * (Bbottom - Btop)
  339.     Move.L    D5,D0            ;  plus a fudge word for slop bits
  340.     Addq    #2,D0            ;  plus one more slop word
  341. ;;    _NewPtr                    ; allocate space for bitmap
  342. ;;    Move.L    A0,baseAddr(A1)    ; Set the destination upper left corner
  343.     Move.L    baseAddr(A1),A0    ; Get the destination upper left corner
  344.     Move.L    A0,LowBound(A6)    ; Save lowest output address
  345.     Add.L    D5,A0            ; Point beyond lower right corner
  346.     Move.L    A0,HiBound(A6)    ; Save Highest output address
  347.     Move.L    baseAddr(A2),A0    ; Get the source upper left corner
  348.     Move.W    InWords(A6),D1    ; Set D1 for GET_REG Macro
  349.  
  350.     Moveq    #0,D0
  351.     Move.B    ROTATION(A6),D0    ; Get the rotation type
  352.     And.W    #7,D0            ; Force to legal, We provide no error check, yet
  353.     Add.W    D0,D0
  354.     Move.W    Jump_Table(PC,D0),D0
  355.     Jmp        Jump_Table(PC,D0)
  356.  
  357. Jump_Table
  358.     DC.W    (Rotate_0 - Jump_Table)
  359.     DC.W    (Rotate_H - Jump_Table)
  360.     DC.W    (Rotate_V - Jump_Table)
  361.     DC.W    (Rotate_X - Jump_Table)
  362.     DC.W    (Rotate_L - Jump_Table)
  363.     DC.W    (Rotate_R - Jump_Table)
  364.     DC.W    (Rotate_FL - Jump_Table)
  365.     DC.W    (Rotate_FR - Jump_Table)
  366. ;
  367. ; The Rotation and Mirror Routines
  368. ;
  369. Rotate_0                        
  370.     Move.L        LowBound(A6),A1    ; Point to upper left corner
  371.     GET_REG        loop0
  372.     GET_WORD
  373.     END_MIRROR    loop0,Add
  374.     Bra            Exit_Rotate
  375.  
  376. Rotate_H
  377.     Move.L        LowBound(A6),A1    ; Point beyond upper right corner
  378.     Add.W        InBytes,A1        ; for predecrement of A1 in data stores
  379.     GET_REG        loopH
  380.     REVERSE_REG
  381.     END_MIRROR    loopH,Add
  382.     Bra            Shift_Left        ; shift image left slop bits
  383.  
  384. Rotate_V
  385.     Move.L        HiBound(A6),A1    ; Point beyond lower right corner
  386.     Sub            #2,A1            ; and never slop adjust
  387.     Sub.W        InBytes,A1
  388.     GET_REG        loopV
  389.     GET_WORD
  390.     END_MIRROR    loopV,Sub
  391.     Bra            Exit_Rotate
  392.  
  393. Rotate_X
  394.     Move.L        HiBound(A6),A1    ; Point beyond lower right corner
  395.                                 ; for predecrement of A1 in data stores
  396.     Move.L        DEST_MAP(A6),A4          ; Get the destination BitMap address
  397.     Move.W        bounds+right(A4),D3
  398.     Sub.W        bounds+left(A4),D3    ; Number of slop bits on the left
  399.     And.W        #$0F,D3                ; Any slop bits to shift in a word ?
  400.     Sub            #2,A1            ; We don't slop adjust later in Shift_Left
  401.     GET_REG        loopX
  402.     REVERSE_REG
  403.     END_MIRROR    loopX,Sub
  404.     Bra            Shift_Left        ; shift image left slop bits
  405.  
  406. Rotate_L
  407.     Move.L        HiBound(A6),A1    ; Point beyond lower right corner
  408.     Sub.W        OutBytes(A6),A1    ; Point to lower left corner
  409.     Sub            #2,A1            ; and never slop adjust
  410.     LOAD_REGS    loopL
  411.     ROT_REGS    l,l
  412.     END_ROTATE    loopL,Sub,Add
  413.     Bra            Exit_Rotate
  414.  
  415. Rotate_R
  416.     Move.L        LowBound(A6),A1
  417.     Add.W        OutBytes(A6),A1
  418.     Sub.L        #2,A1            ; Point to upper right corner
  419.     LOAD_REGS    loopR
  420.     ROT_REGS    l,r
  421.     END_ROTATE    loopR,Add,Sub
  422.     Bra            Shift_Left        ; shift image left slop bits
  423.  
  424. Rotate_FL
  425.     Move.L        LowBound(A6),A1    ; Point to upper left corner
  426.     LOAD_REGS    loopFL
  427.     ROT_REGS    l,l
  428.     END_ROTATE    loopFL,Add,Add
  429.     Bra            Exit_Rotate
  430.  
  431. Rotate_FR
  432.     Move.L        HiBound(A6),A1    ; Point beyond lower right corner
  433.     Sub.L        #2,A1            ; Point to lower right corner
  434.     Move.L        DEST_MAP(A6),A4          ; Get the destination BitMap address
  435.     Move.W        bounds+right(A4),D3
  436.     Sub.W        bounds+left(A4),D3    ; Number of slop bits on the left
  437.     And.W        #$0F,D3                ; Any slop bits to shift in a word ?
  438.     Sub            #2,A1            ; We don't slop adjust later in Shift_Left
  439.     LOAD_REGS    loopFR
  440.     ROT_REGS    l,r
  441.     END_ROTATE    loopFR,Sub,Sub
  442. ;;    Bra            Shift_Left        ; shift image left slop bits
  443.  
  444. ;
  445. ; Routines to shift the BitMap data for any slop around
  446. ; the edges caused by images having heights or widths
  447. ; which are not on word boundaries. Some rotations cause 
  448. ; extra columns or rows to be generated to the left or top
  449. ; of the BitMap, we now must push the image up to the topLeft
  450. ; corner of the Bitmap.
  451. ;
  452. ; Shift left the output BitMap any slop columns
  453. Shift_Left
  454.     Move.L    DEST_MAP(A6),A4          ; Get the destination BitMap address
  455.     Move.W    bounds+right(A4),D3
  456.     Sub.W    bounds+left(A4),D3    ; Number of slop bits on the left
  457.     And.W    #$0F,D3                ; Any slop bits to shift in a word ?
  458.     Beq.s    Exit_Rotate
  459.     Move.L    baseAddr(A4),A0    ; Get the destination upper left corner
  460.     Move.W    OutBytes(A6),D1
  461.     Move.W    OutRows(A6),D2    ; Get the output rows
  462.     Mulu    D1,D2            ; Get total byte size
  463.     Add.L    D2,A0            ; Point to lower right corner
  464.     Lsr.W    #1,D2            ; Convert to words
  465.     Moveq    #16,D4
  466.     Sub.W    D3,D4            ; Number of slop bits
  467.     Move.L    D2,D5
  468.     Lsr.L    #3,D5            ; Loop count in blocks of 8 words
  469.     Move.W    D2,D1
  470.     Neg.W    D1                ; To jump into the loop doing the 
  471.     And.W    #7,D1            ;  block boundary remainder first
  472.     Beq.s    Bit_Loop_End
  473.     Asl.W    #3,D1            ; Multiply by code block size
  474.     Jmp        Bit_loop(PC,D1)    ; Jump into the loop, part way
  475. Bit_loop
  476.     SHIFT_WORDS
  477. Bit_Loop_End
  478.     Dbra    D5,Bit_loop
  479.     
  480. Exit_Rotate
  481.     Movem.L    (sp)+,D2-D7/A2-A5
  482.     Unlk    A6
  483.     Move.L    (sp)+,A0        ; Get return address and
  484.     Add.L    #10,sp            ; pop parameters off stack
  485.     Jmp        (A0)            ; for a Pascal style return
  486.     ENDPROC
  487.     
  488.     END
  489.